home *** CD-ROM | disk | FTP | other *** search
/ Macworld Expo - Develope…Central & Net Innovations / Developer Central and Net Innovators (MacWorld Expo) (January 1999).iso / Developer Central / Bowers Development / Demo AppMaker / Examples / plain C OS8 / AMReminder / MainWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-29  |  8.7 KB  |  455 lines  |  [TEXT/CWIE]
  1. /* MainWindow.c */
  2.  
  3. #include <Types.h>
  4. #include <Quickdraw.h>
  5. #include <Controls.h>
  6. #include <Dialogs.h>
  7. #include <Events.h>
  8. #include <Lists.h>
  9. #include <Menus.h>
  10. #include <Resources.h>
  11. #include <Sound.h>
  12. #include <TextEdit.h>
  13. #include <ToolUtils.h>
  14. #include <Appearance.h>
  15. #include <stdlib.h>
  16.  
  17. #include "Globals.h"
  18. #include "ResourceDefs.h"
  19. #include "DoScrap.h"
  20. #include "Miscellany.h"
  21. #include "Scrolling.h"
  22. #include "ControlUtils.h"
  23. #include "Add.h"
  24. #include "Dispatcher.h"
  25. #include "DDocData.h"
  26. #include "AMReminderEngine.h"
  27. #include "AMReminderDoc.h"
  28. #include "MainWindow.h"
  29.  
  30.  
  31. static    AMReminderEngine*      GetEngine    (MainWindow*    self);
  32.  
  33. static    void    DoUndo        (MainWindow*    self);
  34. static    void    DoCut        (MainWindow*    self);
  35. static    void    DoCopy        (MainWindow*    self);
  36. static    void    DoPaste        (MainWindow*    self);
  37. static    void    DoClear        (MainWindow*    self);
  38. static    void    DoSelectAll        (MainWindow*    self);
  39. static    void    DoShowClipboard    (MainWindow*    self);
  40.  
  41. static    void    DoAddReminder    (MainWindow*        self);
  42. static    void    DoEditReminder    (MainWindow*        self);
  43. static    void    DoDeleteReminder    (MainWindow*        self);
  44. static    void    BuildRemindersList        (ControlHandle        inList);
  45.  
  46. //----------
  47. MainWindow*        NewMainWindow ()
  48. {
  49.     MainWindow*        window;
  50.  
  51.     window = (MainWindow*)malloc (sizeof (MainWindow));
  52.     MainWindow_Init (window);
  53.     SetClassID (window, classMainWindow);
  54.  
  55.     return window;
  56. }
  57.  
  58. //----------
  59. void    DeleteMainWindow (
  60.     MainWindow*        window)
  61. {
  62.     MainWindow_Free (window);
  63.     free (window);
  64. }
  65.  
  66. //----------
  67. void    MainWindow_Create (
  68.     AMDoc*            inDoc,
  69.     DDocData*        inData)
  70. {
  71.     MainWindow*        winObj = NewMainWindow ();
  72.  
  73.     if (winObj != nil) {
  74.         MainWindow_Open (winObj, inDoc, inData);
  75.     }
  76. }
  77.  
  78. //----------
  79. void    MainWindow_Init (
  80.     MainWindow*        self)
  81. {
  82. }
  83.  
  84. //----------
  85. void    MainWindow_Free (
  86.     MainWindow*        self)
  87. {
  88. }
  89.  
  90. //----------
  91. AMReminderEngine*    GetEngine (
  92.     MainWindow*        self)
  93. {
  94.     return (AMReminderEngine*) self->super.mDoc->mEngine;
  95. }
  96.  
  97. /*----------*/
  98. void    MainWindow_Open (
  99.     MainWindow*        self,
  100.     AMDoc*            inDoc,
  101.     DDocData*        inData)
  102. {
  103.     WindowPtr        window;
  104.     Handle            wftb;
  105.  
  106.     self->super.mDoc = inDoc;
  107.     self->mData = inData;
  108.     AddResponder ((AMSignaler*) self->mData, (AMResponder*) self);
  109.  
  110.     window = GetNewCWindow (WIND_MainWindow, nil, (WindowPtr) -1L);
  111.     if (AMEngine_GetFilename (self->super.mDoc->mEngine) [0] != 0) {
  112.         SetWTitle (window, AMEngine_GetFilename (self->super.mDoc->mEngine));
  113.     }
  114.     self->super.mWindow = window;
  115.     ((AMReminderDoc*)self->super.mDoc)->mMainWindowPtr = window;
  116.  
  117.     SetWindowKind (window, 'AM');
  118.     SetWRefCon (window, (long) self);
  119.     SetPort (window);
  120.     SetInfo (window);
  121.  
  122.     wftb = GetResource ('Wftb', WIND_MainWindow);
  123.  
  124.     CreateRootControl (window, &self->super.mRootControl);
  125.  
  126.     self->super.vScroll = nil;
  127.     self->super.hScroll = nil;
  128.  
  129.  
  130.     self->mLogoHandle = GetNewControl (CNTL_Logo, window);
  131.     SetWindowItemFont (self->mLogoHandle, wftb, 1);
  132.  
  133.     self->mYearLabel = GetNewControl (CNTL_Year, window);
  134.     SetWindowItemFont (self->mYearLabel, wftb, 2);
  135.     SetControlFromTEXT (self->mYearLabel, TEXT_Year);
  136.  
  137.     self->mRemindersLabelLabel = GetNewControl (CNTL_RemindersLabel, window);
  138.     SetWindowItemFont (self->mRemindersLabelLabel, wftb, 3);
  139.     SetControlFromTEXT (self->mRemindersLabelLabel, TEXT_RemindersLabel);
  140.  
  141.     self->mRemindersHandle = GetNewControl (CNTL_Reminders, window);
  142.     SetWindowItemFont (self->mRemindersHandle, wftb, 4);
  143.     BuildRemindersList (self->mRemindersHandle);
  144.     SetListBoxChoice (self->mRemindersHandle, GetReminderChoice (self->mData));
  145.  
  146.     self->mAddHandle = GetNewControl (CNTL_Add, window);
  147.     SetWindowItemFont (self->mAddHandle, wftb, 5);
  148.     SetDefaultState (self->mAddHandle, true);
  149.  
  150.     self->mEditHandle = GetNewControl (CNTL_Edit, window);
  151.     SetWindowItemFont (self->mEditHandle, wftb, 6);
  152.  
  153.     self->mDeleteHandle = GetNewControl (CNTL_Delete, window);
  154.     SetWindowItemFont (self->mDeleteHandle, wftb, 7);
  155.  
  156.     AdvanceKeyboardFocus (window);
  157.  
  158.     ShowWindow (window);
  159. }
  160.  
  161. /*----------*/
  162. void    MainWindow_Close (
  163.     MainWindow*        self)
  164. {
  165.     RemoveResponder ((AMSignaler*) self->mData, (AMResponder*) self);
  166.  
  167.     ((AMReminderDoc*)self->super.mDoc)->mMainWindowPtr = nil;
  168.     SetInfo (nil);
  169.     HideWindow (self->super.mWindow);
  170.     DisposeWindow (self->super.mWindow);
  171.  
  172.     DeleteMainWindow (self);
  173. }
  174.  
  175. /*----------*/
  176. void    BuildRemindersList (
  177.     ControlHandle        inControl)
  178. {
  179.     ListHandle        list;
  180.  
  181.     list = GetListHandle (inControl);
  182.     AddToList ("\pOne",   list);
  183.     AddToList ("\pTwo",   list);
  184.     AddToList ("\pThree", list);
  185.     AddToList ("\pInfinity",  list);
  186.  
  187. }
  188.  
  189. /*----------*/
  190. void    MainWindow_Track (
  191.     MainWindow*        self,
  192.     ControlHandle    whichControl,
  193.     short            whichPart,
  194.     Point            where)
  195. {
  196.     Rect            bounds;
  197.     short            newValue;
  198.  
  199.     if (whichControl == self->mRemindersHandle) {
  200.         if (TrackClick (self->mRemindersHandle, where)) {
  201.             SetReminderChoice (self->mData, GetListBoxChoice (self->mRemindersHandle));
  202.         }
  203.     }
  204.     if (whichControl == self->mAddHandle) {
  205.         if (TrackClick (self->mAddHandle, where)) {
  206.             DoAddReminder (self);
  207.         }
  208.     }
  209.     if (whichControl == self->mEditHandle) {
  210.         if (TrackClick (self->mEditHandle, where)) {
  211.             DoEditReminder (self);
  212.         }
  213.     }
  214.     if (whichControl == self->mDeleteHandle) {
  215.         if (TrackClick (self->mDeleteHandle, where)) {
  216.             DoDeleteReminder (self);
  217.         }
  218.     }
  219. }
  220.  
  221. //----------
  222. void    MainWindow_DataChanged (
  223.     MainWindow*        self,
  224.     long            inDataID)
  225. {
  226. }
  227.  
  228. /*----------*/
  229. void    MainWindow_MouseIn (
  230.     MainWindow*        self,
  231.     Point            where,
  232.     short            modifiers)
  233. {
  234.     Rect        bounds;
  235.  
  236. }
  237.  
  238. //----------
  239. void    MainWindow_ExitCurField (
  240.     MainWindow*        self)
  241. {
  242.     ControlHandle    focus;
  243.  
  244.     GetKeyboardFocus (self->super.mWindow, &focus);
  245.  
  246.     if (focus == nil) {
  247.         // nothing to exit
  248.  
  249.     }
  250. }
  251.  
  252. /*----------*/
  253. void    MainWindow_TypeIn (
  254.     MainWindow*        self,
  255.     char            ch)
  256. {
  257.     ControlHandle    focus;
  258.     short            keyCode;
  259.  
  260.     GetKeyboardFocus (self->super.mWindow, &focus);
  261.  
  262.     if ((ch == charEnter)
  263.     ||  (ch == charReturn)) {
  264.         MainWindow_ExitCurField (self);    // Dispatch
  265.         SimulateClick (self->mAddHandle);
  266.         DoAddReminder;
  267.     } else if (ch == charEsc) {
  268.     } else if (ch == charTab) {
  269.         AMWindow_DoTab ((AMWindow*) self, (curEvent.modifiers & optionKey) != 0);
  270.     } else if (focus != nil) {
  271.         keyCode = curEvent.message & keyCodeMask;
  272.         HandleControlKey (focus, keyCode, ch, curEvent.modifiers);
  273.         AMEngine_SetDirty (self->super.mDoc->mEngine);
  274.     } else {
  275.         SysBeep (1);
  276.     }
  277. }
  278.  
  279. /*----------*/
  280. void    MainWindow_Resize (
  281.     MainWindow*        self)
  282. {
  283.     /* application-specific code to resize items in window */
  284. }
  285.  
  286. /*----------*/
  287. void    MainWindow_Scroll (
  288.     MainWindow*        self,
  289.     short            newValue,
  290.     short            oldValue)
  291. {
  292.     /* application-specific code to scroll window */
  293.     if (gWhichScroll == self->super.vScroll) {
  294.     } else {    // horizontal
  295.     }
  296. }
  297.  
  298. //----------
  299. void    DoUndo (
  300.     MainWindow*        self)
  301. {
  302. } // DoUndo
  303.  
  304. //----------
  305. void    DoCut (
  306.     MainWindow*        self)
  307. {
  308.     TEHandle        curTE = AMWindow_GetCurTE ((AMWindow*) self);
  309.  
  310.     if (curTE != nil) {
  311.         TECut (curTE);
  312.         AMEngine_SetDirty (self->super.mDoc->mEngine);
  313.         scrapDirty = true;
  314.     }
  315. } // DoCut
  316.  
  317. //----------
  318. void    DoCopy (
  319.     MainWindow*        self)
  320. {
  321.     TEHandle        curTE = AMWindow_GetCurTE ((AMWindow*) self);
  322.  
  323.     if (curTE != nil) {
  324.         TECopy (curTE);
  325.         scrapDirty = true;
  326.     }
  327. } // DoCopy
  328.  
  329. //----------
  330. void    DoPaste (
  331.     MainWindow*        self)
  332. {
  333.     TEHandle        curTE = AMWindow_GetCurTE ((AMWindow*) self);
  334.  
  335.     if (curTE != nil) {
  336.         TEPaste (curTE);
  337.         AMEngine_SetDirty (self->super.mDoc->mEngine);
  338.     }
  339. } // DoPaste
  340.  
  341. //----------
  342. void    DoClear (
  343.     MainWindow*        self)
  344. {
  345.     TEHandle        curTE = AMWindow_GetCurTE ((AMWindow*) self);
  346.  
  347.     if (curTE != nil) {
  348.         TEDelete (curTE);
  349.         AMEngine_SetDirty (self->super.mDoc->mEngine);
  350.     }
  351. } // DoClear
  352.  
  353. //----------
  354. void    DoSelectAll (
  355.     MainWindow*        self)
  356. {
  357.     TEHandle        curTE = AMWindow_GetCurTE ((AMWindow*) self);
  358.  
  359.     if (curTE != nil) {
  360.         TESetSelect (0, 32767, curTE);
  361.     }
  362. } // DoSelectAll
  363.  
  364. //----------
  365. void    DoShowClipboard (
  366.     MainWindow*        self)
  367. {
  368. } // DoShowClipboard
  369.  
  370. //----------
  371. void    DoAddReminder (
  372. MainWindow*        self)
  373. {
  374.     DReminder*        data;
  375.  
  376.     data = NewDReminder ();
  377.  
  378.     // initialize data
  379.  
  380.     if (GetAdd (data)) {
  381.         // user clicked OK, so
  382.         // do something with data
  383.     }
  384.     DeleteDReminder (data);
  385. }
  386.  
  387. //----------
  388. void    DoEditReminder (
  389. MainWindow*        self)
  390. {
  391.     DReminder*        data;
  392.  
  393.     data = NewDReminder ();
  394.  
  395.     // initialize data
  396.  
  397.     if (GetAdd (data)) {
  398.         // user clicked OK, so
  399.         // do something with data
  400.     }
  401.     DeleteDReminder (data);
  402. }
  403.  
  404. //----------
  405. void    DoDeleteReminder (
  406. MainWindow*        self)
  407. {
  408. }
  409.  
  410. //----------
  411. Boolean        MainWindow_DoCommand (
  412.     MainWindow*        self,
  413.     long            inCommand)
  414. {
  415.     Boolean        result = true;
  416.  
  417.     switch (inCommand) {
  418.         case cmdUndo:
  419.                 DoUndo (self);
  420.             break;
  421.         case cmdCut:
  422.                 DoCut (self);
  423.             break;
  424.         case cmdCopy:
  425.                 DoCopy (self);
  426.             break;
  427.         case cmdPaste:
  428.                 DoPaste (self);
  429.             break;
  430.         case cmdClear:
  431.                 DoClear (self);
  432.             break;
  433.         case cmdSelectAll:
  434.                 DoSelectAll (self);
  435.             break;
  436.         case cmdShowClipboard:
  437.                 DoShowClipboard (self);
  438.             break;
  439.         case cmdAddReminder:
  440.                 DoAddReminder (self);
  441.             break;
  442.         case cmdEditReminder:
  443.                 DoEditReminder (self);
  444.             break;
  445.         case cmdDeleteReminder:
  446.                 DoDeleteReminder (self);
  447.             break;
  448.  
  449.         default:
  450.                 result = false;
  451.     } // switch
  452.  
  453.     return result;
  454. }
  455.